home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource2 / sclib_1 / 1_1 / v7n1106a.txt < prev    next >
Encoding:
Text File  |  1995-11-01  |  4.9 KB  |  189 lines
  1.  
  2.  
  3. The following CROBOTS program is provided as an example.
  4.  
  5.  
  6. /* sniper */
  7. /* strategy: since a scan of the entire battlefield can be done in 90 */
  8. /* degrees from a corner, sniper can scan the field quickly. */
  9.  
  10. /* external variables, that can be used by any function */
  11. int corner;           /* current corner 0, 1, 2, or 2 */
  12. int c1x, c1y;         /* corner 1 x and y */
  13. int c2x, c2y;         /*   "    2 "  "  " */
  14. int c3x, c3y;         /*   "    3 "  "  " */
  15. int c4x, c4y;         /*   "    4 "  "  " */
  16. int s1, s2, s3, s4;   /* starting scan position for corner 1 - 4 */
  17. int sc;               /* current scan start */
  18. int d;                /* last damage check */
  19.  
  20. /* main */
  21. main()
  22. {
  23. int closest;        /* check for targets in range */
  24. int range;          /* range to target */
  25. int dir;            /* scan direction */
  26.  
  27. /* initialize the corner info */
  28. /* x and y location of a corner, and starting scan degree */
  29. c1x = 10;  c1y = 10;  s1 = 0;
  30. c2x = 10;  c2y = 990; s2 = 270;
  31. c3x = 990; c3y = 990; s3 = 180;
  32. c4x = 990; c4y = 10;  s4 = 90;
  33. closest = 9999;
  34. new_corner();       /* start at a random corner */ 
  35. d = damage();       /* get current damage */
  36. dir = sc;           /* starting scan direction */ 
  37.  
  38. while (1) {         /* loop is executed forever */
  39.  
  40.   while (dir < sc + 90) {  /* scan through 90 degree range */
  41. range = scan(dir,1);   /* look at a direction */
  42. if (range <= 700 && range > 0) { 
  43. while (range > 0) {    /* keep firing while in range */
  44.   closest = range;     /* set closest flag */
  45.   cannon(dir,range);   /* fire! */
  46.   range = scan(dir,1); /* check target again */
  47.   if (d + 15 > damage())  /* sustained several hits, */ 
  48.     range = 0;            /* goto new corner */
  49. }
  50. dir -= 10;             /* back up scan, in case */
  51. }
  52.  
  53. dir += 2;                /* increment scan */
  54. if (d != damage()) {     /* check for damage incurred */
  55. new_corner();          /* we're hit, move now */
  56. d = damage();
  57. dir = sc;
  58. }
  59.   }
  60.  
  61.   if (closest == 9999) {       /* check for any targets in range */
  62. new_corner();             /* nothing, move to new corner */
  63. d = damage();
  64. dir = sc;
  65.   } else                      /* targets in range, resume */
  66. dir = sc;
  67.   closest = 9999;
  68. } 
  69.  
  70. }  /* end of main */
  71.  
  72. /* new corner function to move to a different corner */
  73. new_corner() {
  74. int x, y;
  75. int angle;
  76. int new;
  77.  
  78. new = rand(4);           /* pick a random corner */
  79. if (new == corner)       /* but make it different than the */
  80.   corner = (new + 1) % 4;/* current corner */
  81. else
  82.   corner = new;
  83. if (corner == 0) {       /* set new x,y and scan start */
  84.   x = c1x; 
  85.   y = c1y; 
  86.   sc = s1;
  87. } 
  88. if (corner == 1) {
  89.   x = c2x; 
  90.   y = c2y; 
  91.   sc = s2;
  92. }
  93. if (corner == 2) {
  94.   x = c3x; 
  95.   y = c3y; 
  96.   sc = s3;
  97. }
  98. if (corner == 3) { 
  99.   x = c4x; 
  100.   y = c4y; 
  101.   sc = s4;
  102. }
  103.  
  104. /* find the heading we need to get to the desired corner */
  105. angle = plot_course(x,y);
  106.  
  107. /* start drive train, full speed */
  108. drive(angle,100);
  109.  
  110. /* keep traveling until we are within 100 meters */
  111. /* speed is checked in case we run into wall, other robot */
  112. /* not terribly great, since were are doing nothing while moving */
  113.  
  114. while (distance(loc_x(),loc_y(),x,y) > 100 && speed() > 0)
  115.   ;
  116.  
  117. /* cut speed, and creep the rest of the way */
  118.  
  119. drive(angle,20);
  120. while (distance(loc_x(),loc_y(),x,y) > 10 && speed() > 0)
  121.   ;
  122.  
  123. /* stop drive, should coast in the rest of the way */
  124. drive(angle,0); 
  125. }  /* end of new_corner */
  126.  
  127. /* classical pythagorean distance formula */
  128. distance(x1,y1,x2,y2)
  129. int x1;
  130. int y1;
  131. int x2;
  132. int y2;
  133. {
  134. int x, y;
  135.  
  136. x = x1 - x2;
  137. y = y1 - y2;
  138. d = sqrt((x*x) + (y*y));
  139. return(d);
  140. }
  141.  
  142. /* plot course function, return degree heading to */
  143. /* reach destination x, y; uses atan() trig function */
  144. plot_course(xx,yy)
  145. int xx, yy;
  146. {
  147. int d;
  148. int x,y;
  149. int scale;
  150. int curx, cury;
  151.  
  152. scale = 100000;  /* scale for trig functions */
  153. curx = loc_x();  /* get current location */
  154. cury = loc_y();
  155. x = curx - xx;
  156. y = cury - yy;
  157.  
  158. /* atan only returns -90 to +90, so figure out how to use */
  159. /* the atan() value */
  160.  
  161. if (x == 0) {      /* x is zero, we either move due north or south */
  162.   if (yy > cury)
  163. d = 90;        /* north */
  164.   else
  165. d = 270;       /* south */
  166. } else {
  167.   if (yy < cury) {
  168. if (xx > curx)
  169. d = 360 + atan((scale * y) / x);  /* south-east, quadrant 4 */
  170. else
  171. d = 180 + atan((scale * y) / x);  /* south-west, quadrant 3 */ 
  172.   } else {
  173. if (xx > curx)
  174. d = atan((scale * y) / x);        /* north-east, quadrant 1 */
  175. else
  176. d = 180 + atan((scale * y) / x);  /* north-west, quadrant 2 */
  177.   }
  178. }
  179. return (d);
  180. }
  181.  
  182. Notes:  The distance() and plot_course() routines are
  183. quite handy. Save them for your programs. Also, note that the
  184. main scan routine will "back up" a few degrees after a target has
  185. been found and fired upon. This should catch robots trying to
  186. flee away from the direction you are scanning. If the target
  187. moves the other way, the normal scan increment will find it.
  188.  
  189.